#ifndef GODOT_POOLARRAY_HPP
#define GODOT_POOLARRAY_HPP

#include "Variant.hpp"



namespace Godot
{
class PoolByteArray:public godot_pool_byte_array
{
public:
    constexpr static auto VariantAs=&godot_gdnative_core_api_struct::godot_variant_as_pool_byte_array;
    PoolByteArray()
    {
        Godot::GODOT_CORE_API->godot_pool_byte_array_new(this);
    }
    PoolByteArray(const PoolByteArray &p_v)
    {
        Godot::GODOT_CORE_API->godot_pool_byte_array_new_copy(this,&p_v);
    }
    PoolByteArray& operator=(const PoolByteArray& p_v)
    {

        GODOT_CORE_API->godot_pool_byte_array_destroy(this);

        GODOT_CORE_API->godot_pool_byte_array_new_copy(this,&p_v);
        return *this;

    }
    PoolByteArray(PoolByteArray&& p_v)
    {
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);
    }
    PoolByteArray& operator=(PoolByteArray&& p_v)
    {

        GODOT_CORE_API->godot_pool_byte_array_destroy(this);
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);

        return *this;

    }
    ~PoolByteArray()
    {
        GODOT_CORE_API->godot_pool_byte_array_destroy(this);
    }
///Other
    static inline const uint8_t* read_access_get_ptr(godot_pool_array_read_access* p_v)
    {
        return Godot::GODOT_CORE_API->godot_pool_byte_array_read_access_ptr(p_v);
    }

    inline uint8_t get(int i);

    inline godot_pool_byte_array_read_access * get_read_access();

};


inline uint8_t PoolByteArray::get(int i)
{
    return Godot::GODOT_CORE_API->godot_pool_byte_array_get(this,i);
}

inline godot_pool_byte_array_read_access * PoolByteArray::get_read_access()
{
    return Godot::GODOT_CORE_API->godot_pool_byte_array_read(this);
}













class PoolRealArray:public godot_pool_real_array
{
public:
    constexpr static auto VariantAs=&godot_gdnative_core_api_struct::godot_variant_as_pool_real_array;
    PoolRealArray()
    {
        Godot::GODOT_CORE_API->godot_pool_real_array_new(this);
    }
    PoolRealArray(const PoolRealArray &p_v)
    {
        Godot::GODOT_CORE_API->godot_pool_real_array_new_copy(this,&p_v);
    }
    PoolRealArray& operator=(const PoolRealArray& p_v)
    {

        GODOT_CORE_API->godot_pool_real_array_destroy(this);

        GODOT_CORE_API->godot_pool_real_array_new_copy(this,&p_v);
        return *this;

    }
    PoolRealArray(PoolRealArray&& p_v)
    {
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);
    }
    PoolRealArray& operator=(PoolRealArray&& p_v)
    {

        GODOT_CORE_API->godot_pool_real_array_destroy(this);
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);

        return *this;

    }
    ~PoolRealArray()
    {
        GODOT_CORE_API->godot_pool_real_array_destroy(this);
    }
///Other
    static inline const float* read_access_get_ptr(godot_pool_array_read_access* p_v)
    {
        return Godot::GODOT_CORE_API->godot_pool_real_array_read_access_ptr(p_v);
    }

    inline float get(int i);

    inline godot_pool_real_array_read_access * get_read_access();
};

inline float PoolRealArray::get(int i)
{
    return Godot::GODOT_CORE_API->godot_pool_real_array_get(this,i);
}

inline godot_pool_real_array_read_access * PoolRealArray::get_read_access()
{
    return Godot::GODOT_CORE_API->godot_pool_real_array_read(this);
}















class PoolVector2Array:public godot_pool_vector2_array
{
public:
    constexpr static auto VariantAs=&godot_gdnative_core_api_struct::godot_variant_as_pool_vector2_array;
    PoolVector2Array()
    {
        Godot::GODOT_CORE_API->godot_pool_vector2_array_new(this);
    }
    PoolVector2Array(const PoolVector2Array &p_v)
    {
        Godot::GODOT_CORE_API->godot_pool_vector2_array_new_copy(this,&p_v);
    }
    PoolVector2Array& operator=(const PoolVector2Array& p_v)
    {

        GODOT_CORE_API->godot_pool_vector2_array_destroy(this);

        GODOT_CORE_API->godot_pool_vector2_array_new_copy(this,&p_v);
        return *this;

    }
    PoolVector2Array(PoolVector2Array&& p_v)
    {
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);
    }
    PoolVector2Array& operator=(PoolVector2Array&& p_v)
    {

        GODOT_CORE_API->godot_pool_vector2_array_destroy(this);
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);

        return *this;

    }
    ~PoolVector2Array()
    {
        GODOT_CORE_API->godot_pool_vector2_array_destroy(this);
    }
///Other
    static inline const godot_vector2* read_access_get_ptr(godot_pool_array_read_access* p_v)
    {
        return Godot::GODOT_CORE_API->godot_pool_vector2_array_read_access_ptr(p_v);
    }

    inline godot_vector2 get(int i);

    inline godot_pool_vector2_array_read_access * get_read_access();
};

inline godot_vector2 PoolVector2Array::get(int i)
{
    return Godot::GODOT_CORE_API->godot_pool_vector2_array_get(this,i);
}

inline godot_pool_vector2_array_read_access * PoolVector2Array::get_read_access()
{
    return Godot::GODOT_CORE_API->godot_pool_vector2_array_read(this);
}








class PoolVector3Array:public godot_pool_vector3_array
{
public:
  constexpr static auto VariantAs=&godot_gdnative_core_api_struct::godot_variant_as_pool_vector3_array;
    PoolVector3Array()
    {
        Godot::GODOT_CORE_API->godot_pool_vector3_array_new(this);
    }
    PoolVector3Array(const PoolVector3Array &p_v)
    {
        Godot::GODOT_CORE_API->godot_pool_vector3_array_new_copy(this,&p_v);
    }
    PoolVector3Array& operator=(const PoolVector3Array& p_v)
    {

        GODOT_CORE_API->godot_pool_vector3_array_destroy(this);

        GODOT_CORE_API->godot_pool_vector3_array_new_copy(this,&p_v);
        return *this;

    }
    PoolVector3Array(PoolVector3Array&& p_v)
    {
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);
    }
    PoolVector3Array& operator=(PoolVector3Array&& p_v)
    {

        GODOT_CORE_API->godot_pool_vector3_array_destroy(this);
        *(POINTER_T*)_dont_touch_that=*(POINTER_T*)(p_v._dont_touch_that);

        return *this;

    }
    ~PoolVector3Array()
    {
        GODOT_CORE_API->godot_pool_vector3_array_destroy(this);
    }
///Other
    static inline const godot_vector3* read_access_get_ptr(godot_pool_array_read_access* p_v)
    {
        return Godot::GODOT_CORE_API->godot_pool_vector3_array_read_access_ptr(p_v);
    }

    inline godot_vector3 get(int i);

    inline godot_pool_vector3_array_read_access * get_read_access();
};

inline godot_vector3 PoolVector3Array::get(int i)
{
    return Godot::GODOT_CORE_API->godot_pool_vector3_array_get(this,i);
}

inline godot_pool_vector3_array_read_access * PoolVector3Array::get_read_access()
{
    return Godot::GODOT_CORE_API->godot_pool_vector3_array_read(this);
}








/*
class PoolIntArray:public godot_pool_int_array{
	PoolIntArray(const godot_pool_int_array& p_v){*this=p_v;}
	public:
	PoolIntArray(){Godot::CORE_API->godot_pool_int_array_new(this);}
	PoolIntArray(const PoolIntArray& p_v){Godot::CORE_API->godot_pool_int_array_new_copy(this,&p_v);}



};


class PoolStringArray:public godot_pool_string_array{
	PoolStringArray(const godot_pool_string_array& p_v){*this=p_v;}
	public:
	PoolStringArray(){Godot::CORE_API->godot_pool_string_array_new(this);}
	PoolStringArray(const PoolStringArray& p_v){Godot::CORE_API->godot_pool_string_array_new_copy(this,&p_v);}


	operator Variant(){godot_variant ret;Godot::CORE_API->godot_variant_new_pool_string_array(&ret,this);return ret;}
};
*/
/*



class PoolColorArray:public godot_pool_color_array{
	PoolColorArray(const godot_pool_color_array& p_v){*this=p_v;}
	public:
	PoolColorArray(){Godot::CORE_API->godot_pool_color_array_new(this);}
	PoolColorArray(const PoolColorArray& p_v){Godot::CORE_API->godot_pool_color_array_new_copy(this,&p_v);}


	operator Variant(){godot_variant ret;Godot::CORE_API->godot_variant_new_pool_color_array(&ret,this);return ret;}
};
*/

}

#endif // GODOT_POOLARRAY_HPP
